/*
* Copyright (C) 2010-2011 Mamadou Diop.
*
* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DOUBANGO is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with DOUBANGO.
*
*/
#include "Xcap.h"

#include "Common.h"

unsigned XcapStack::count = 0;

/* === ANSI-C functions (local use) === */
static int stack_callback(const thttp_event_t *httpevent);

/* =================================== XCAP Event ==================================== */
typedef enum twrap_xcap_step_type_e {
    txst_name,
    txst_pos,
    txst_att,
    txst_pos_n_att,
    txst_ns
}
twrap_xcap_step_type_t;

typedef struct twrap_xcap_step_s {
    TSK_DECLARE_OBJECT;

    twrap_xcap_step_type_t type;
    char* qname;
    char* att_qname;
    char* att_value;
    unsigned pos;
    struct {
        char* prefix;
        char* value;
    } ns;
}
twrap_xcap_step_t;

static tsk_object_t* twrap_xcap_step_ctor(tsk_object_t * self, va_list * app)
{
    twrap_xcap_step_t *step = (twrap_xcap_step_t *)self;
    if(step) {
    }
    return self;
}

static tsk_object_t* twrap_xcap_step_dtor(tsk_object_t * self)
{
    twrap_xcap_step_t *step = (twrap_xcap_step_t *)self;
    if(step) {
        TSK_FREE(step->qname);
        TSK_FREE(step->att_qname);
        TSK_FREE(step->att_value);
        TSK_FREE(step->ns.prefix);
        TSK_FREE(step->ns.value);
    }

    return self;
}

static const tsk_object_def_t twrap_xcap_step_def_s = {
    sizeof(twrap_xcap_step_t),
    twrap_xcap_step_ctor,
    twrap_xcap_step_dtor,
    tsk_null,
};
const tsk_object_def_t *twrap_xcap_step_def_t = &twrap_xcap_step_def_s;

twrap_xcap_step_t* twrap_xcap_step_create(twrap_xcap_step_type_t type)
{
    twrap_xcap_step_t* step;
    if((step = (twrap_xcap_step_t*)tsk_object_new(twrap_xcap_step_def_t))) {
        step->type = type;
    }
    return step;
}

XcapSelector::XcapSelector(XcapStack* stack)
    : auid(tsk_null)
{
    if(stack) {
        this->stack_handle = tsk_object_ref(stack->getHandle());
    }
    this->steps = tsk_list_create();
}


XcapSelector* XcapSelector::setAUID(const char* auid)
{
    tsk_strupdate(&this->auid, auid);
    return this;
}

XcapSelector* XcapSelector::setName(const char* qname)
{
    twrap_xcap_step_t* step;
    if((step = twrap_xcap_step_create(txst_name))) {
        step->qname = tsk_strdup(qname);
        tsk_list_push_back_data(this->steps, (void**)&step);
    }
    return this;
}

XcapSelector* XcapSelector::setAttribute(const char* qname, const char* att_qname, const char* att_value)
{
    twrap_xcap_step_t* step;
    if((step = twrap_xcap_step_create(txst_att))) {
        step->qname = tsk_strdup(qname);
        step->att_qname = tsk_strdup(att_qname);
        step->att_value = tsk_strdup(att_value);
        tsk_list_push_back_data(this->steps, (void**)&step);
    }
    return this;
}

XcapSelector* XcapSelector::setPos(const char* qname, unsigned pos)
{
    twrap_xcap_step_t* step;
    if((step = twrap_xcap_step_create(txst_pos))) {
        step->qname = tsk_strdup(qname);
        step->pos = pos;
        tsk_list_push_back_data(this->steps, (void**)&step);
    }
    return this;
}

XcapSelector* XcapSelector::setPosAttribute(const char* qname, unsigned pos, const char* att_qname, const char* att_value)
{
    twrap_xcap_step_t* step;
    if((step = twrap_xcap_step_create(txst_pos))) {
        step->qname = tsk_strdup(qname);
        step->pos = pos;
        step->att_qname = tsk_strdup(att_qname);
        step->att_value = tsk_strdup(att_value);
        tsk_list_push_back_data(this->steps, (void**)&step);
    }
    return this;
}

XcapSelector* XcapSelector::setNamespace(const char* prefix, const char* value)
{
    twrap_xcap_step_t* step;
    if((step = twrap_xcap_step_create(txst_ns))) {
        step->ns.prefix = tsk_strdup(prefix);
        step->ns.value = tsk_strdup(value);
        tsk_list_push_back_data(this->steps, (void**)&step);
    }
    return this;
}

/* From tinyXCAP::txcap_selector_get_node_2() */
char* XcapSelector::getString()
{
    char* node = tsk_null;
    char* temp = tsk_null;
    char* _namespace = tsk_null;
    tsk_buffer_t* buffer = tsk_buffer_create_null();
    const tsk_list_item_t* item;
    const twrap_xcap_step_t* step;

    /* Node */
    tsk_list_foreach(item, this->steps) {
        step = (twrap_xcap_step_t*)item->data;
        switch(step->type) {
        case txst_name:
            if(tsk_buffer_append_2(buffer, "/%s", step->qname)) {
                goto bail;
            }
            break;

        case txst_pos:
            tsk_buffer_append_2(buffer, "/%s%%5B%u%%5D",
                                step->att_qname, step->pos);
            break;

        case txst_att:
            tsk_buffer_append_2(buffer, "/%s%%5B@%s=%%22%s%%22%%5D",
                                step->qname, step->att_qname, step->att_value);
            break;

        case txst_pos_n_att:
            tsk_buffer_append_2(buffer, "/%s%%5B%u%%5D%%5B@%s=%%22%s%%22%%5D",
                                step->qname, step->pos, step->att_qname, step->att_value);
            break;

        case txst_ns:
            tsk_sprintf(&temp, "%sxmlns(%s=%%22%s%%22)",
                        _namespace?"":"%3F", step->ns.prefix, step->ns.value);
            tsk_strcat(&_namespace, temp);
            TSK_FREE(temp);
            break;


        } /* switch */
    } /* for */

    /* append the namespace */
    if(_namespace) {
        tsk_buffer_append(buffer, _namespace, (tsk_size_t)tsk_strlen(_namespace));
        TSK_FREE(_namespace);
    }

bail:
    if(TSK_BUFFER_DATA(buffer) && TSK_BUFFER_SIZE(buffer)) {
        node = tsk_strndup((const char*)TSK_BUFFER_DATA(buffer), TSK_BUFFER_SIZE(buffer));
    }
    TSK_OBJECT_SAFE_FREE(buffer);


    /* Document */
    if(this->auid) {
        char* document;
        if((document = txcap_selector_get_document(this->stack_handle, this->auid))) {
            if(node) {
                tsk_strcat_2(&document, "/~~/%s%s", this->auid, node);
                TSK_FREE(node);
            }
            return document;
        }
    }

    return node;
}

void XcapSelector::reset()
{
    TSK_FREE(this->auid);
    tsk_list_clear_items(this->steps);
}

XcapSelector::~XcapSelector()
{
    this->reset();
    TSK_OBJECT_SAFE_FREE(this->steps);

    tsk_object_unref(this->stack_handle);
}

/* =================================== XCAP Message ==================================== */
XcapMessage::XcapMessage() :
    httpmessage(tsk_null)
{
}

XcapMessage::XcapMessage(const thttp_message_t *_httpmessage)
{
    this->httpmessage = _httpmessage;
}

XcapMessage::~XcapMessage()
{
}

short XcapMessage::getCode() const
{
    if(this->httpmessage) {
        return this->httpmessage->line.response.status_code;
    }
    return 0;
}

const char* XcapMessage::getPhrase() const
{
    if(this->httpmessage) {
        return this->httpmessage->line.response.reason_phrase;
    }
    return tsk_null;
}

char* XcapMessage::getXcapHeaderValue(const char* name, unsigned index /*= 0*/)
{
    const thttp_header_t* header;
    if((header = thttp_message_get_headerByName(this->httpmessage, name))) {
        return thttp_header_value_tostring(header);
    }
    return tsk_null;
}

char* XcapMessage::getXcapHeaderParamValue(const char* name, const char* pname, unsigned index /*= 0*/)
{
    const thttp_header_t* header;
    if((header = thttp_message_get_headerByName(this->httpmessage, name))) {
        const tsk_param_t* param;
        if((param = tsk_params_get_param_by_name(header->params, pname))) {
            return tsk_strdup(param->value);
        }
    }
    return tsk_null;
}

unsigned XcapMessage::getXcapContentLength()
{
    if(this->httpmessage && this->httpmessage->Content) {
        return this->httpmessage->Content->size;
    }
    return 0;
}

unsigned XcapMessage::getXcapContent(void* output, unsigned maxsize)
{
    unsigned retsize = 0;
    if(output && maxsize && this->httpmessage->Content) {
        retsize = (this->httpmessage->Content->size > maxsize) ? maxsize : this->httpmessage->Content->size;
        memcpy(output, this->httpmessage->Content->data, retsize);
    }
    return retsize;
}


/* =================================== XCAP Event ==================================== */
XcapEvent::XcapEvent(const thttp_event_t *_httpevent)
{
    this->httpevent = _httpevent;
    if(_httpevent) {
        this->httpmessage = new XcapMessage(_httpevent->message);
    }
    else {
        this->httpmessage = tsk_null;
    }
}

XcapEvent::~XcapEvent()
{
    if(this->httpmessage) {
        delete this->httpmessage;
    }
}

thttp_event_type_t XcapEvent::getType()
{
    return this->httpevent->type;
}

const XcapMessage* XcapEvent::getXcapMessage() const
{
    return this->httpmessage;
}




/* =================================== XCAP Callback ==================================== */
XcapCallback::XcapCallback()
{
}

XcapCallback::~XcapCallback()
{
}





/* =================================== XCAP Stack ==================================== */
XcapStack::XcapStack(XcapCallback* _callback, const char* xui, const char* password, const char* xcap_root)
{
    /* Initialize network layer */
    if(XcapStack::count == 0) {
        tnet_startup();
    }

    this->callback = _callback;
    this->handle = txcap_stack_create(stack_callback, xui, password, xcap_root,
                                      TXCAP_STACK_SET_USERDATA(this),
                                      TXCAP_STACK_SET_NULL());
}

XcapStack::~XcapStack()
{
    TSK_OBJECT_SAFE_FREE(this->handle);

    /* DeInitialize the network layer (only if last stack) */
    if(--XcapStack::count == 0) {
        tnet_cleanup();
    }
}

bool XcapStack::registerAUID(const char* id, const char* mime_type, const char* ns, const char* document_name, bool is_global)
{
    txcap_stack_t* stack = (txcap_stack_t*)this->handle;
    if(stack) {
        tsk_bool_t _global = is_global?tsk_true:tsk_false; // 32bit <-> 64bit workaround
        return (txcap_auid_register(stack->auids, id, mime_type, ns, document_name, _global) == 0);
    }
    return false;
}

bool XcapStack::start()
{
    return (txcap_stack_start(this->handle) == 0);
}

bool XcapStack::setCredentials(const char* xui, const char* password)
{
    return txcap_stack_set(this->handle,
                           TXCAP_STACK_SET_XUI(xui),
                           TXCAP_STACK_SET_PASSWORD(password),
                           TXCAP_STACK_SET_NULL()) == 0;
}

bool XcapStack::setXcapRoot(const char* xcap_root)
{
    return txcap_stack_set(this->handle,
                           TXCAP_STACK_SET_ROOT(xcap_root),
                           TXCAP_STACK_SET_NULL()) == 0;
}

bool XcapStack::setLocalIP(const char* ip)
{
    return txcap_stack_set(this->handle,
                           TXCAP_STACK_SET_LOCAL_IP(ip),
                           TXCAP_STACK_SET_NULL()) == 0;
}

bool XcapStack::setLocalPort(unsigned port)
{
    tsk_istr_t port_str;
    tsk_itoa(port, &port_str);
    return txcap_stack_set(this->handle,
                           TXCAP_STACK_SET_LOCAL_PORT(port_str),
                           TXCAP_STACK_SET_NULL()) == 0;
}

bool XcapStack::addHeader(const char* name, const char* value)
{
    return txcap_stack_set(this->handle,
                           TXCAP_STACK_SET_HEADER(name, value),
                           TXCAP_STACK_SET_NULL()) == 0;
}

bool XcapStack::removeHeader(const char* name)
{
    return txcap_stack_set(this->handle,
                           TXCAP_STACK_UNSET_HEADER(name),
                           TXCAP_STACK_SET_NULL()) == 0;
}

bool XcapStack::setTimeout(unsigned timeout)
{
    tsk_istr_t timeout_str;
    tsk_itoa(timeout, &timeout_str);
    return txcap_stack_set(this->handle,
                           TXCAP_STACK_SET_TIMEOUT(timeout_str),
                           TXCAP_STACK_SET_NULL()) == 0;
}

bool XcapStack::getDocument(const char* url)
{
    return txcap_action_fetch_document(this->handle,
                                       TXCAP_ACTION_SET_REQUEST_URI(url),
                                       TXCAP_ACTION_SET_NULL()) == 0;
}

bool XcapStack::getElement(const char* url)
{
    return txcap_action_fetch_element(this->handle,
                                      TXCAP_ACTION_SET_REQUEST_URI(url),
                                      TXCAP_ACTION_SET_NULL()) == 0;
}

bool XcapStack::getAttribute(const char* url)
{
    return txcap_action_fetch_attribute(this->handle,
                                        TXCAP_ACTION_SET_REQUEST_URI(url),
                                        TXCAP_ACTION_SET_NULL()) == 0;
}

bool XcapStack::deleteDocument(const char* url)
{
    return txcap_action_delete_document(this->handle,
                                        TXCAP_ACTION_SET_REQUEST_URI(url),
                                        TXCAP_ACTION_SET_NULL()) == 0;
}

bool XcapStack::deleteElement(const char* url)
{
    return txcap_action_delete_element(this->handle,
                                       TXCAP_ACTION_SET_REQUEST_URI(url),
                                       TXCAP_ACTION_SET_NULL()) == 0;
}

bool XcapStack::deleteAttribute(const char* url)
{
    return txcap_action_delete_attribute(this->handle,
                                         TXCAP_ACTION_SET_REQUEST_URI(url),
                                         TXCAP_ACTION_SET_NULL()) == 0;
}


bool XcapStack::putDocument(const char* url, const void* payload, unsigned len, const char* contentType)
{
    return txcap_action_create_document(this->handle,
                                        TXCAP_ACTION_SET_REQUEST_URI(url),
                                        TXCAP_ACTION_SET_PAYLOAD(payload, len),
                                        TXCAP_ACTION_SET_HEADER("Content-Type", contentType),
                                        TXCAP_ACTION_SET_NULL()) == 0;
}

bool XcapStack::putElement(const char* url, const void* payload, unsigned len)
{
    return txcap_action_create_element(this->handle,
                                       TXCAP_ACTION_SET_REQUEST_URI(url),
                                       TXCAP_ACTION_SET_PAYLOAD(payload, len),
                                       TXCAP_ACTION_SET_NULL()) == 0;
}

bool XcapStack::putAttribute(const char* url, const void* payload, unsigned len)
{
    return txcap_action_create_attribute(this->handle,
                                         TXCAP_ACTION_SET_REQUEST_URI(url),
                                         TXCAP_ACTION_SET_PAYLOAD(payload, len),
                                         TXCAP_ACTION_SET_NULL()) == 0;
}


bool XcapStack::stop()
{
    return (txcap_stack_stop(this->handle) == 0);
}


int stack_callback(const thttp_event_t *httpevent)
{
    const XcapStack* stack = tsk_null;
    XcapEvent* e = tsk_null;

    const txcap_stack_handle_t* stack_handle = thttp_session_get_userdata(httpevent->session);
    if(!stack_handle || !(stack = dyn_cast<const XcapStack*>((const XcapStack*)stack_handle))) {
        TSK_DEBUG_ERROR("Invalid user data");
        return -1;
    }

    if(stack->getCallback()) {
        if((e = new XcapEvent(httpevent))) {
            stack->getCallback()->onEvent(e);
            delete e;
        }
    }
    return 0;
}



